package intelligentCustomer.memory;

import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.store.embedding.EmbeddingMatch;
import intelligentCustomer.session.Message;
import intelligentCustomer.session.UserSession;
import intelligentCustomer.intent.Intent;

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.time.LocalDateTime;

/**
 * 记忆管理器
 * 负责协调短期记忆、长期记忆和工作记忆
 */
public class MemoryManager {
    /** 用户档案缓存 */
    private final Map<String, UserProfile> userProfiles = new ConcurrentHashMap<>();
    
    /** 记忆存储库 */
    private final VectorMemoryRepository memoryRepository;
    
    /** 工作记忆映射表 */
    private final Map<String, WorkingMemory> workingMemories = new ConcurrentHashMap<>();
    
    /**
     * 构造函数
     * 
     * @param memoryRepository 记忆存储库
     */
    public MemoryManager() {
        this.memoryRepository = new VectorMemoryRepository();
    }
    
    /**
     * 获取用户档案（长期记忆）
     * 
     * @param userId 用户ID
     * @return 用户档案对象
     */
    public UserProfile getUserProfile(String userId) {
        if (!userProfiles.containsKey(userId)) {
            UserProfile profile = memoryRepository.loadUserProfile(userId);
            userProfiles.put(userId, profile);
        }
        return userProfiles.get(userId);
    }
    
    /**
     * 获取工作记忆
     * 
     * @param userId 用户ID
     * @return 工作记忆对象
     */
    public WorkingMemory getWorkingMemory(String userId) {
        if (!workingMemories.containsKey(userId)) {
            workingMemories.put(userId, new WorkingMemory());
        }
        return workingMemories.get(userId);
    }
    
    /**
     * 更新记忆
     * 分析会话内容，更新用户档案和工作记忆
     * 
     * @param userId 用户ID
     * @param session 当前会话
     */
    public void updateMemory(String userId, UserSession session) {
        UserProfile profile = getUserProfile(userId);
        WorkingMemory workingMemory = getWorkingMemory(userId);
        
        // 分析会话历史，提取关键信息
        List<Message> history = session.getHistory();
        for (Message message : history) {
            // 保存对话记忆到向量数据库
            memoryRepository.saveConversationMemory(
                userId, 
                message.getRole(), 
                message.getContent(), 
                message.getTimestamp()
            );
            
            if ("用户".equals(message.getRole())) {
                extractAndUpdateMemory(profile, workingMemory, message.getContent());
            }
        }
        
        // 保存更新后的用户档案
        memoryRepository.saveUserProfile(profile);
    }
    
    /**
     * 提取消息中的关键信息并更新记忆
     * 
     * @param profile 用户档案
     * @param workingMemory 工作记忆
     * @param content 消息内容
     */
    private void extractAndUpdateMemory(UserProfile profile, WorkingMemory workingMemory, String content) {
        // 提取产品偏好
        if (content.contains("手机") || content.contains("智能手机")) {
            profile.addProductPreference("smartphone");
            workingMemory.setCurrentTopic("smartphone");
        }
        
        if (content.contains("笔记本") || content.contains("电脑")) {
            profile.addProductPreference("laptop");
            workingMemory.setCurrentTopic("laptop");
        }
        
        // 提取价格敏感度
        if (content.contains("便宜") || content.contains("优惠") || content.contains("打折")) {
            profile.setPriceSensitivity("high");
        }
        
        // 记录查询频率
        profile.incrementQueryCount();
    }
    
    /**
     * 生成记忆摘要
     * 
     * @param userId 用户ID
     * @param currentQuery 当前查询
     * @return 记忆摘要文本
     */
    public String generateMemorySummary(String userId, String currentQuery) {
        UserProfile profile = getUserProfile(userId);
        WorkingMemory workingMemory = getWorkingMemory(userId);
        
        StringBuilder summary = new StringBuilder();
        summary.append("用户记忆摘要:\n");
        
        // 添加用户基本信息
        summary.append("用户ID: ").append(userId).append("\n");
        summary.append("查询次数: ").append(profile.getQueryCount()).append("\n");
        
        // 添加产品偏好
        summary.append("产品偏好: ");
        List<String> preferences = profile.getProductPreferences();
        if (preferences.isEmpty()) {
            summary.append("未知\n");
        } else {
            for (String pref : preferences) {
                summary.append(pref).append(", ");
            }
            summary.append("\n");
        }
        
        // 添加价格敏感度
        summary.append("价格敏感度: ").append(profile.getPriceSensitivity()).append("\n");
        
        // 添加当前工作记忆
        summary.append("当前关注: ").append(workingMemory.getCurrentTopic()).append("\n");
        
        // 从向量数据库检索相关历史对话
        summary.append("\n相关历史对话:\n");
        List<EmbeddingMatch<TextSegment>> relevantMemories = 
            memoryRepository.retrieveRelevantMemories(currentQuery, 3);
        
        for (EmbeddingMatch<TextSegment> match : relevantMemories) {
            String memoryText = match.embedded().text();
            if (memoryText.contains("TYPE: conversation")) {
                String role = extractField(memoryText, "ROLE:");
                String content = extractField(memoryText, "CONTENT:");
                summary.append(role).append(": ").append(content).append("\n");
            }
        }
        
        return summary.toString();
    }
    
    /**
     * 从文本中提取字段值
     * 
     * @param text 文本
     * @param fieldName 字段名
     * @return 字段值
     */
    private String extractField(String text, String fieldName) {
        if (text.contains(fieldName)) {
            int start = text.indexOf(fieldName) + fieldName.length();
            int end = text.indexOf("\n", start);
            if (end == -1) end = text.length();
            return text.substring(start, end).trim();
        }
        return "";
    }
    
    /**
     * 结束会话时保存记忆
     * 
     * @param userId 用户ID
     */
    public void saveMemory(String userId) {
        if (userProfiles.containsKey(userId)) {
            memoryRepository.saveUserProfile(userProfiles.get(userId));
        }
    }

    /**
     * 保存会话历史到长期记忆
     * 
     * @param userId 用户ID
     * @param history 会话历史消息列表
     */
    public void saveSessionHistory(String userId, List<Message> history) {
        // 将会话历史保存到向量存储库中
        for (Message message : history) {
            if (message.getRole().equals("用户")) {
                // 使用已有的saveConversationMemory方法
                memoryRepository.saveConversationMemory(
                    userId, 
                    message.getRole(), 
                    message.getContent(), 
                    message.getTimestamp()
                );
            }
        }
        
        System.out.println("已保存用户 " + userId + " 的会话历史，共 " + history.size() + " 条消息");
    }

    /**
     * 更新记忆
     * 
     * @param userId 用户ID
     * @param query 用户查询
     * @param response 系统回复
     * @param intent 识别的意图
     */
    public void updateMemory(String userId, String query, String response, Intent intent) {
        UserProfile profile = getUserProfile(userId);
        WorkingMemory workingMemory = getWorkingMemory(userId);
        
        // 保存对话记忆到向量数据库
        memoryRepository.saveConversationMemory(
            userId, 
            "用户", 
            query, 
            LocalDateTime.now()
        );
        
        memoryRepository.saveConversationMemory(
            userId, 
            "系统", 
            response, 
            LocalDateTime.now()
        );
        
        // 提取和更新记忆
        extractAndUpdateMemory(profile, workingMemory, query);
        
        // 保存更新后的用户档案
        memoryRepository.saveUserProfile(profile);
    }
}